package com.szewec.ps.util;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.media.MediaMetadataRetriever;
import android.os.Environment;
import android.text.TextUtils;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class BitmapFileSetting {
    /**
     * 三星,小米手机设置
     * 三星,小米手机拍照要旋转
     *
     * @param filePath 文件路径
     * @return 文件对象
     * @throws IOException
     */
    public static File settingFileDegree(String filePath) throws IOException {
        //根据图片路径转bitmap
        Bitmap bitMBitmap = BitmapFactory.decodeFile(filePath);
        if (bitMBitmap == null) {
            return null;
        }
        //根据图片判断要旋转多少角度
        int bitmapDegree = getBitmapDegree(filePath);
        if(bitmapDegree == 0){//如果图片没有旋转,则不需要处理

            return new File(filePath);
        }
        //旋转后的bitmap
        Bitmap rotateBitmapByDegree = rotateBitmapByDegree(bitMBitmap, bitmapDegree);
        return saveBitmapFile(rotateBitmapByDegree, filePath);
    }


    /**
     *
     * @param filePath 原本的文件路径
     * @return 返回一个新的文件路径
     * @throws IOException
     */
    public static String settingFileDegreeToNewFilePath(String filePath) throws IOException {
        //根据图片路径转bitmap
        boolean isImage = isImageFile(filePath);
        if(isImage){
            Bitmap bitmap = BitmapFactory.decodeFile(filePath);
            //根据图片判断要旋转多少角度
            int bitmapDegree = getBitmapDegree(filePath);
            if(bitmapDegree == 0){//如果图片没有旋转,则不需要处理
                return saveBitmapToNewFilePath(bitmap, filePath);
            }
            //旋转后的bitmap
            Bitmap newBitmap = rotateBitmapByDegree(bitmap, bitmapDegree);
            return saveBitmapToNewFilePath(newBitmap, filePath);
        }
        return filePath;
    }

    /**
     * 把batmap 转file
     *
     * @param bitmap
     * @param filepath
     */
    private static File saveBitmapFile(Bitmap bitmap, String filepath) {
        File file = new File(filepath);//将要保存图片的路径
        try {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
            bos.flush();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return file;
    }


    /**
     * 用于截取视频第一帧，返回图片路径
     * @param bitmap bitmap对象
     * @return 返回一个新的文件路径
     */
    private static String saveBitmapToNewFilePath(Bitmap bitmap) {
        File fileDir = new File(Environment.getExternalStorageDirectory(), "Photo");
        if (!fileDir.exists()) {
            fileDir.mkdir();
        }
        String newFilePath = fileDir.getAbsolutePath() + "/" + Constants.FIRST_FRAME;
        BitmapCompressUtil.compressImage(newFilePath,bitmap, 1);//压缩图片质量，不能大于1M
        return newFilePath;
    }

    /**
     *  用于照片压缩后返回新的图片路径
     * @param bitmap bitmap对象
     * @param filepath 原本的文件路径
     * @return 返回一个新的文件路径
     */
    private static String saveBitmapToNewFilePath(Bitmap bitmap, String filepath) {
        File fileDir = new File(Environment.getExternalStorageDirectory(), "Photo");
        if (!fileDir.exists()) {
            fileDir.mkdir();
        }
        String newFilePath = fileDir.getAbsolutePath() + "/invisible_test" + getSuffix(filepath);
        BitmapCompressUtil.compressImage(newFilePath, bitmap,20);//图片大小大于20M，则进行压缩
        return newFilePath;
    }

    /**
     * 获取文件名及后缀
     */
    private static String getSuffix(String path) {
        if (TextUtils.isEmpty(path)) {
            return "";
        }
        int start = path.lastIndexOf(".");
        if (start != -1) {
            return path.substring(start);
        } else {
            return "";
        }
    }

    /**
     * 读取图片的旋转的角度
     *
     * @param path 图片绝对路径
     * @return 图片的旋转角度
     * @throws IOException
     */
    private static int getBitmapDegree(String path) throws IOException {
        int degree = 0;
        // 从指定路径下读取图片，并获取其EXIF信息
        ExifInterface exifInterface = new ExifInterface(path);
        // 获取图片的旋转信息
        int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_NORMAL);
        switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                degree = 90;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                degree = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                degree = 270;
                break;
        }

        return degree;
    }

    /**
     * 将图片按照某个角度进行旋转
     *
     * @param bm     需要旋转的图片
     * @param degree 旋转角度
     * @return 旋转后的图片
     */
    private static Bitmap rotateBitmapByDegree(Bitmap bm, int degree) {
        Bitmap returnBm = null;
        // 根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);

        // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
        returnBm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), matrix, true);

        if (returnBm == null) {
            returnBm = bm;
        }
        if (bm != returnBm) {
            bm.recycle();
        }
        return returnBm;
    }

    /**
     * 获取本地视频的第一帧
     *
     * @param localPath
     * @return
     */
    public static String getLocalVideoBitmap(String localPath) {
        Bitmap bitmap = null;
        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
        try {
            //根据文件路径获取缩略图
            retriever.setDataSource(localPath);
            //获得第一帧图片
            bitmap = retriever.getFrameAtTime();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } finally {
            retriever.release();
        }
        if(bitmap != null){
            return saveBitmapToNewFilePath(bitmap);
        }else {
            return null;
        }
    }

    /**
     * 判断一个文件是否是图片文件的方法
     * @param filePath
     * @return
     */
    public static boolean isImageFile(String filePath) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);
        if (options.outWidth == -1) {
            return false;
        }
        return true;
    }

}